package collection.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * JDK8之后，java利用IO的流连接思路，为集合构建了流式API，让我们操作集合元素时
 * 以流水线式的层层加工，完成操作。
 */
public class StreamAPIDemo1 {
    public static void main(String[] args) {
        //创建一个集合，存入10个100以内的随机数
        Random random = new Random();
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(random.nextInt(10));
        }
        System.out.println(list);
        /*
            JDK8之后，集合提供了一个方法:
            Stream<E> stream()
            将当前集合转变为一个"流"
            这个流相当与IO中的流的感觉，只不过其中流动的是集合中的每个元素

            我们可以在流上添加若干的中间环节，中间环节相当于IO流连接中的高级流
            中间环节负责将流中的元素加工，加工后，将加工后的元素传递给下一个环节

            最后，在流上添加一个终止环节，终止环节得到最终的处理结果
            结果可能是一个新的集合，也可能是一个统计的数据等等。

            常见的中间环节:
            map: 将流中的每个元素加工，加工后，将加工后的元素传递给下一个环节
            filter: 将流中的每个元素进行过滤，过滤后，将过滤后的元素传递给下一个环节
            distinct: 将流中的每个元素进行去重，去重后，将去重后的元素传递给下一个环节
            sorted: 将流中的每个元素进行排序，排序后，将排序后的元素传递给下一个环节

            常见的终止环节:
            collect: 将流中的每个元素收集到一个新的集合中，并返回这个集合
         */
        //将集合每个元素扩大3倍
        List<Integer> list2 = list.stream()//将集合转换为一个"流"
                              .map(e->e*3) //中间环节用于将每个元素扩大3被
                              .collect(Collectors.toList());//终止环节收集所有中间环节处理完毕后流动过来的所有元素
        System.out.println(list2);

        //获取集合中所有的偶数
        List<Integer> list3 = list.stream()//将集合转换为一个"流"
                              .filter(e->e%2==0)
                              .collect(Collectors.toList());//终止环节收集所有中间环节处理完毕后流动过来的所有元素
        System.out.println(list3);

        //去除集合中的重复元素
        List<Integer> list4 = list.stream()//将集合转换为一个"流"
                              .distinct()
                              .collect(Collectors.toList());//终止环节收集所有中间环节处理完毕后流动过来的所有元素
        System.out.println(list4);

        //排序集合元素
        List<Integer> list5 = list.stream()//将集合转换为一个"流"
//                              .sorted()//默认升序
                              .sorted((o1,o2)->o2-o1)//可以自行指定比较规则
                              .collect(Collectors.toList());//终止环节收集所有中间环节处理完毕后流动过来的所有元素
        System.out.println(list5);


        /*
            将list集合元素扩大5被并从小到达排序(降序)然后去除重复值后获取所有的偶数
         */
        List<Integer> list6 = list.stream().distinct()
                                           .filter(e->e%2==0)
                                           .map(e->e*5)
                                           .sorted((o1,o2)->o2-o1)
                                           .collect(Collectors.toList());
        System.out.println(list6);
    }
}
